#if 0
#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<string.h>

#define BUFFER_SIZE 256

int main()
{
    int pipefd[2];//0表示读端，1表示写端
    char message[]="hello child process!!";
    char buffer[BUFFER_SIZE];//用于接收消息的缓冲区

    if(pipe(pipefd)==-1)//创建管道失败
    {
        perror("pipe error!!!");
        exit(EXIT_FAILURE);//利用退出状态码退出
    }
    
    pid_t pid=fork();//创建子进程
    if(pid<0)
    {
        perror("build child process error!!!");
        exit(EXIT_FAILURE);
    }

    if(pid==0)
    {
        close(pipefd[1]);//关闭读端，子进程只能读取数据
        read(pipefd[0],buffer,BUFFER_SIZE);//将管道内数据写入到buffer中

        printf("管道内数据为：%s\n",buffer);

        close(pipefd[0]);//关闭写端
    }
    else
    {
        close(pipefd[0]);//关闭写端，父进程写入数据
        write(pipefd[1],message,strlen(message)+1);

        printf("管道内写入数据为:%s\n",message);

        close(pipefd[1]);
    }
    return 0;
}

#include<stdio.h>
#include<stdlib.h>
#include<pthread.h>


void* thread_function()
{
    printf("成功进程创建线程的逻辑代码！！！\n");
    pthread_exit(NULL);//退出线程
}
int main()
{
    pthread_t pthread;//定义一个线程变量
    int result=pthread_create(&pthread,NULL,thread_function,NULL);//参数为线程变量地址，线程属性，空为默认属性，线程函数，线程函数参数

    if(result!=0)
    {
        perror("线程创建失败！！！");
        exit(EXIT_FAILURE);
    }

    result = pthread_join(pthread, NULL);//等待特定线程退出，空表示不关心返回值
    if(result!=0)
    {
        perror("等待线程退出失败！！！");
        exit(EXIT_FAILURE);
    }

    return 0;
}

#include<stdio.h>
#include<stdlib.h>
#include<pthread.h>

#define BUFFER_SIZE 5//缓冲区的最大物品数量

int buffer[BUFFER_SIZE];//数据存储区
int count=0;

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;//互斥锁
pthread_cond_t full_cond = PTHREAD_COND_INITIALIZER;//缓冲区满条件
pthread_cond_t empty_cond = PTHREAD_COND_INITIALIZER;//缓冲区空条件

void* producer()//生产者线程函数
{
    int item=0;//生产者已生产的物品数量
    while(1)
    {
        pthread_mutex_lock(&mutex);//加锁变为原子操作

        while(count==BUFFER_SIZE)//若缓冲区已满，则需要等待消费者处理数据
        {
            pthread_cond_wait(&full_cond,&mutex);
        }

        buffer[count]=item;//生产一个数据
        printf("生产物品数量为：%d\n",item);
        count++;

        pthread_cond_signal(&empty_cond);//等待唤醒消费者
        pthread_mutex_unlock(&mutex);

        item++;
    }
}

void* consumer()
{
    while(1)
    {
        pthread_mutex_lock(&mutex);//加锁操作

        while(count==0)//缓冲区中为空，则需要等待生产者产生数据
        {
            pthread_cond_wait(&empty_cond,&mutex);
        }

        int item=buffer[count-1];
        printf("消费者消费的数据：%d\n",item);
        count--;

        pthread_cond_signal(&full_cond);//唤起生产者
        pthread_mutex_unlock(&mutex);//解锁操作
    }
}
int main()
{
    pthread_t producer_thread,consumer_thread;//定义线程变量

    pthread_create(&producer_thread,NULL,producer,NULL);//创建生产者消费者线程模型
    pthread_create(&consumer_thread,NULL,consumer,NULL);

    pthread_join(producer_thread,NULL);//等待线程退出
    pthread_join(consumer_thread,NULL);
    return 0;
}

#include<stdio.h>

typedef struct//定义一个数据类
{
    int data;
}Singleton;

Singleton instance={.data=0};//创建一个全局的数据类，并初始化为0

Singleton* getInstance()
{
    return &instance;//返回单例实例化的地址
}
int main()
{
    Singleton* Singleton=getInstance();//获取实例化指针
    printf("单例模式下的实例化数据：%d\n",Singleton->data);
    return 0;
}
#endif

#include<stdio.h>
#include<stdlib.h>

typedef struct 
{
    int data;
}Singleton;

Singleton* getInstance()//懒汉单例模式
{
    static Singleton* instance=NULL;//局部静态变量，用于保存实例化地址
    if(instance==NULL)
    {
        instance=(Singleton*)malloc(sizeof(Singleton));//分配内存空间，创建新的实例化对象
        instance->data=1;//初始化
    }
    return instance;
}

int main()
{
    Singleton* Singleton=getInstance();
    
    printf("懒汉模式实例化对象数据：%d\n",Singleton->data);
    return 0;
}